eslint-plugin-flowtype
Advanced tools
eslint-plugin-flowtype is an ESLint plugin that provides linting rules for Flow type annotations. It helps ensure that your Flow type annotations are correct and consistent, improving the reliability and maintainability of your code.
Type Annotations
This rule ensures that every file has a valid Flow file annotation. The code sample demonstrates a simple function with Flow type annotations for the parameters and return type.
/* eslint flowtype/require-valid-file-annotation: [2, "always"] */
// @flow
function add(a: number, b: number): number {
return a + b;
}Type Definitions
This rule ensures that all Flow type definitions are defined correctly. The code sample shows a type definition for a User object and an instance of that type.
/* eslint flowtype/define-flow-type: 2 */
// @flow
type User = {
name: string,
age: number
};
const user: User = { name: 'John', age: 30 };Type Casting
This rule enforces a naming convention for type identifiers. The code sample demonstrates a type definition that follows the specified naming convention.
/* eslint flowtype/type-id-match: [2, "^([A-Z][a-z0-9]+)+Type$"] */
// @flow
type UserType = {
name: string,
age: number
};
const user: UserType = { name: 'John', age: 30 };eslint-plugin-typescript is an ESLint plugin that provides linting rules for TypeScript code. It offers similar functionality to eslint-plugin-flowtype but is designed for TypeScript instead of Flow. It helps ensure that your TypeScript code is correct and consistent.
typescript-eslint is a set of tools that allows ESLint to lint TypeScript code. It includes an ESLint plugin and a parser that can handle TypeScript syntax. Like eslint-plugin-flowtype, it helps maintain code quality and consistency, but it is tailored for TypeScript.
Flow type linting rules for ESLint.
array-style-complex-typearray-style-simple-typeboolean-styledefine-flow-typedelimiter-danglegeneric-spacingnewline-after-flow-annotationno-dupe-keysno-existential-typeno-flow-fix-me-commentsno-mutable-arrayno-primitive-constructor-typesno-types-missing-file-annotationno-unused-expressionsno-weak-typesobject-type-delimiterrequire-exact-typerequire-parameter-typerequire-return-typerequire-types-at-toprequire-valid-file-annotationrequire-variable-typesemisort-keysspace-after-type-colonspace-before-generic-bracketspace-before-type-colontype-id-matchtype-import-styleunion-intersection-spacinguse-flow-typevalid-syntaxbabel-eslint parser (ESLint parser does not support type annotations).eslint-plugin-flowtype plugin.npm install eslint --save-dev
npm install babel-eslint --save-dev
npm install eslint-plugin-flowtype --save-dev
parser property to babel-eslint.plugins section and specify eslint-plugin-flowtype as a plugin.{
"parser": "babel-eslint",
"plugins": [
"flowtype"
],
"rules": {
"flowtype/boolean-style": [
2,
"boolean"
],
"flowtype/define-flow-type": 1,
"flowtype/delimiter-dangle": [
2,
"never"
],
"flowtype/generic-spacing": [
2,
"never"
],
"flowtype/no-primitive-constructor-types": 2,
"flowtype/no-types-missing-file-annotation": 2,
"flowtype/no-weak-types": 2,
"flowtype/object-type-delimiter": [
2,
"comma"
],
"flowtype/require-parameter-type": 2,
"flowtype/require-return-type": [
2,
"always",
{
"annotateUndefined": "never"
}
],
"flowtype/require-valid-file-annotation": 2,
"flowtype/semi": [
2,
"always"
],
"flowtype/space-after-type-colon": [
2,
"always"
],
"flowtype/space-before-generic-bracket": [
2,
"never"
],
"flowtype/space-before-type-colon": [
2,
"never"
],
"flowtype/type-id-match": [
2,
"^([A-Z][a-z0-9]+)+Type$"
],
"flowtype/union-intersection-spacing": [
2,
"always"
],
"flowtype/use-flow-type": 1,
"flowtype/valid-syntax": 1
},
"settings": {
"flowtype": {
"onlyFilesWithFlowAnnotation": false
}
}
}
This plugin exports a recommended configuration that enforces Flow type good practices.
To enable this configuration use the extends property in your .eslintrc config file:
{
"extends": [
"plugin:flowtype/recommended"
],
"plugins": [
"flowtype"
]
}
See ESLint documentation for more information about extending configuration files.
The following are third-party submitted/ maintained configurations of eslint-plugin-flowtype:
onlyFilesWithFlowAnnotationWhen true, only checks files with a @flow annotation in the first comment.
{
"settings": {
"flowtype": {
"onlyFilesWithFlowAnnotation": true
}
}
}
array-style-complex-typeThe --fix option on the command line automatically fixes problems reported by this rule.
Enforces a particular annotation style of complex types.
Type is considered complex in these cases:
This rule takes one argument.
If it is 'verbose' then a problem is raised when using Type[] instead of Array<Type>.
If it is 'shorthand' then a problem is raised when using Array<Type> instead of Type[].
The default value is 'verbose'.
The following patterns are considered problems:
type X = (?string)[]
// Message: Use "Array<?string>", not "(?string)[]"
// Options: ["verbose"]
type X = (?string)[]
// Message: Use "Array<?string>", not "(?string)[]"
// Options: ["shorthand"]
type X = Array<?string>
// Message: Use "(?string)[]", not "Array<?string>"
// Options: ["shorthand"]
type X = Array<{foo: string}>
// Message: Use "{foo: string}[]", not "Array<{foo: string}>"
type X = (string | number)[]
// Message: Use "Array<string | number>", not "(string | number)[]"
type X = (string & number)[]
// Message: Use "Array<string & number>", not "(string & number)[]"
type X = [string, number][]
// Message: Use "Array<[string, number]>", not "[string, number][]"
type X = {foo: string}[]
// Message: Use "Array<{foo: string}>", not "{foo: string}[]"
type X = (string => number)[]
// Message: Use "Array<string => number>", not "(string => number)[]"
type X = {
foo: string,
bar: number
}[]
// Message: Use "Array<{ foo: string, bar: number }>", not "{ foo: string, bar: number }[]"
type X = {
foo: string,
bar: number,
quo: boolean,
hey: Date
}[]
// Message: Use "Array<Type>", not "Type[]"
The following patterns are not considered problems:
type X = Array<?string>
// Options: ["verbose"]
type X = Array<?string>
// Options: ["shorthand"]
type X = (?string)[]
// Options: ["shorthand"]
type X = Array<string>
// Options: ["shorthand"]
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
type X = Array<?string>
array-style-simple-typeThe --fix option on the command line automatically fixes problems reported by this rule.
Enforces a particular array type annotation style of simple types.
Type is considered simple in these cases:
This rule takes one argument.
If it is 'verbose' then a problem is raised when using Type[] instead of Array<Type>.
If it is 'shorthand' then a problem is raised when using Array<Type> instead of Type[].
The default value is 'verbose'.
The following patterns are considered problems:
type X = string[]
// Message: Use "Array<string>", not "string[]"
// Options: ["verbose"]
type X = string[]
// Message: Use "Array<string>", not "string[]"
// Options: ["shorthand"]
type X = Array<string>
// Message: Use "string[]", not "Array<string>"
type X = Date[]
// Message: Use "Array<Date>", not "Date[]"
type X = Promise<string>[]
// Message: Use "Array<Promise<string>>", not "Promise<string>[]"
type X = $Keys<{foo: string}>[]
// Message: Use "Array<$Keys<{foo: string}>>", not "$Keys<{foo: string}>[]"
type X = any[]
// Message: Use "Array<any>", not "any[]"
type X = mixed[]
// Message: Use "Array<mixed>", not "mixed[]"
type X = void[]
// Message: Use "Array<void>", not "void[]"
type X = null[]
// Message: Use "Array<null>", not "null[]"
type X = string[][]
// Message: Use "Array<string[]>", not "string[][]"
// Message: Use "Array<string>", not "string[]"
type X = Promise<{
foo: string,
bar: number
}>[]
// Message: Use "Array<Promise<{ foo: string, bar: number }>>", not "Promise<{ foo: string, bar: number }>[]"
type X = Promise<{
foo: string,
bar: number,
quo: boolean
}>[]
// Message: Use "Array<Type>", not "Type[]"
The following patterns are not considered problems:
type X = Array<string>
// Options: ["verbose"]
type X = Array<string>
// Options: ["shorthand"]
type X = string[]
type X = Array<Array<string>>
// Options: ["verbose"]
type X = (?string)[]
// Options: ["verbose"]
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
type X = string[]
boolean-styleThe --fix option on the command line automatically fixes problems reported by this rule.
Enforces a particular style for boolean type annotations. This rule takes one argument.
If it is 'boolean' then a problem is raised when using bool instead of boolean.
If it is 'bool' then a problem is raised when using boolean instead of bool.
The default value is 'boolean'.
The following patterns are considered problems:
type X = bool
// Message: Use "boolean", not "bool"
// Options: ["boolean"]
type X = bool
// Message: Use "boolean", not "bool"
// Options: ["bool"]
type X = boolean
// Message: Use "bool", not "boolean"
The following patterns are not considered problems:
type X = boolean
// Options: ["boolean"]
type X = boolean
// Options: ["bool"]
type X = bool
// Options: ["boolean"]
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
type X = bool
define-flow-typeMarks Flow type identifiers as defined.
Used to suppress no-undef reporting of type identifiers.
The following patterns are not considered problems:
var a: AType
// Additional rules: {"no-undef":2}
var a: AType; var b: AType
// Additional rules: {"no-undef":2}
var a; (a: AType)
// Additional rules: {"no-undef":2}
var a: AType<BType>
// Additional rules: {"no-undef":2}
type A = AType
// Additional rules: {"no-undef":2}
declare type A = number
// Additional rules: {"no-undef":2}
opaque type A = AType
// Additional rules: {"no-undef":2}
function f(a: AType) {}
// Additional rules: {"no-undef":2}
function f(a: AType.a) {}
// Additional rules: {"no-undef":2}
function f(a: AType.a.b) {}
// Additional rules: {"no-undef":2}
function f(a): AType {}; var a: AType
// Additional rules: {"no-undef":2}
function f(a): AType {}
// Additional rules: {"no-undef":2}
class C { a: AType }
// Additional rules: {"no-undef":2}
class C { a: AType.a }
// Additional rules: {"no-undef":2}
class C { a: AType.a.b }
// Additional rules: {"no-undef":2}
class C implements AType {}
// Additional rules: {"no-undef":2}
interface AType {}
// Additional rules: {"no-undef":2}
declare interface A {}
// Additional rules: {"no-undef":2}
({ a: ({b() {}}: AType) })
// Additional rules: {"no-undef":2}
type X = {Y<AType>(): BType}
// Additional rules: {"no-undef":2}
interface AType<BType> {}
// Additional rules: {"no-undef":2}
var a: AType
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
var a: AType; var b: AType
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
var a; (a: AType)
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
var a: AType<BType>
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
type A = AType
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
declare type A = number
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
opaque type A = AType
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
function f(a: AType) {}
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
function f(a: AType.a) {}
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
function f(a: AType.a.b) {}
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
function f(a): AType {}; var a: AType
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
function f(a): AType {}
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
class C { a: AType }
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
class C { a: AType.a }
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
class C { a: AType.a.b }
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
class C implements AType {}
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
interface AType {}
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
declare interface A {}
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
({ a: ({b() {}}: AType) })
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
type X = {Y<AType>(): BType}
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
interface AType<BType> {}
// Additional rules: {"no-undef":2,"no-use-before-define":[2,"nofunc"]}
delimiter-dangleThe --fix option on the command line automatically fixes problems reported by this rule.
Enforces consistent use of trailing commas in Object and Tuple annotations.
This rule takes one argument which mirrors ESLint's default comma-dangle rule.
If it is 'never' then a problem is raised when there is a trailing comma.
If it is 'always' then a problem is raised when there is no trailing comma.
If it is 'always-multiline' then a problem is raised when there is no trailing comma on a multi-line definition, or there is a trailing comma on a single-line definition.
If it is 'only-multiline' then a problem is raised when there is a trailing comma on a single-line definition. It allows, but does not enforce, trailing commas on multi-line definitions.
The default value is 'never'.
The following patterns are considered problems:
type X = { foo: string, }
// Message: Unexpected trailing delimiter
// Options: ["never"]
type X = { foo: string, }
// Message: Unexpected trailing delimiter
// Options: ["never"]
type X = { foo: string; }
// Message: Unexpected trailing delimiter
// Options: ["never"]
type X = {
foo: string,
}
// Message: Unexpected trailing delimiter
// Options: ["always"]
type X = { foo: string }
// Message: Missing trailing delimiter
// Options: ["always"]
type X = {
foo: string
}
// Message: Missing trailing delimiter
// Options: ["always-multiline"]
type X = { foo: string, }
// Message: Unexpected trailing delimiter
// Options: ["always-multiline"]
type X = {
foo: string
}
// Message: Missing trailing delimiter
// Options: ["only-multiline"]
type X = { foo: string; }
// Message: Unexpected trailing delimiter
// Options: ["never"]
type X = { [key: string]: number, }
// Message: Unexpected trailing delimiter
// Options: ["always"]
type X = { [key: string]: number }
// Message: Missing trailing delimiter
// Options: ["always-multiline"]
type X = { [key: string]: number, }
// Message: Unexpected trailing delimiter
// Options: ["always-multiline"]
type X = {
[key: string]: number
}
// Message: Missing trailing delimiter
// Options: ["only-multiline"]
type X = { [key: string]: number; }
// Message: Unexpected trailing delimiter
// Options: ["never"]
type X = { [key: string]: number, foo: string, }
// Message: Unexpected trailing delimiter
// Options: ["never"]
type X = {
[key: string]: number,
foo: string,
}
// Message: Unexpected trailing delimiter
// Options: ["never"]
type X = {
[key: string]: number,
aReallyLongPropertyNameHere: string,
}
// Message: Unexpected trailing delimiter
// Options: ["always"]
type X = { [key: string]: number, foo: string }
// Message: Missing trailing delimiter
// Options: ["always"]
type X = {
[key: string]: number;
foo: string
}
// Message: Missing trailing delimiter
// Options: ["always-multiline"]
type X = { [key: string]: number, foo: string, }
// Message: Unexpected trailing delimiter
// Options: ["always-multiline"]
type X = {
[key: string]: number,
foo: string
}
// Message: Missing trailing delimiter
// Options: ["only-multiline"]
type X = { [key: string]: number, foo: string, }
// Message: Unexpected trailing delimiter
// Options: ["never"]
type X = { foo: string, [key: string]: number, }
// Message: Unexpected trailing delimiter
// Options: ["never"]
type X = {
foo: string,
[key: string]: number,
}
// Message: Unexpected trailing delimiter
// Options: ["never"]
type X = {
aReallyLongPropertyNameHere: string,
[key: string]: number,
}
// Message: Unexpected trailing delimiter
// Options: ["always"]
type X = { foo: string, [key: string]: number }
// Message: Missing trailing delimiter
// Options: ["always"]
type X = { foo: string; [key: string]: number }
// Message: Missing trailing delimiter
// Options: ["always-multiline"]
type X = { foo: string, [key: string]: number; }
// Message: Unexpected trailing delimiter
// Options: ["always-multiline"]
type X = {
foo: string,
[key: string]: number
}
// Message: Missing trailing delimiter
// Options: ["only-multiline"]
type X = { foo: string, [key: string]: number; }
// Message: Unexpected trailing delimiter
type X = [string, number,]
// Message: Unexpected trailing delimiter
// Options: ["never"]
type X = [string, number,]
// Message: Unexpected trailing delimiter
// Options: ["never"]
type X = [
string,
number,
]
// Message: Unexpected trailing delimiter
// Options: ["always"]
type X = [string, number]
// Message: Missing trailing delimiter
// Options: ["always"]
type X = [
string,
number
]
// Message: Missing trailing delimiter
// Options: ["always-multiline"]
type X = [string, number,]
// Message: Unexpected trailing delimiter
// Options: ["always-multiline"]
type X = [
foo, string
]
// Message: Missing trailing delimiter
// Options: ["only-multiline"]
type X = [ number, string, ]
// Message: Unexpected trailing delimiter
The following patterns are not considered problems:
type X = { foo: string }
// Options: ["never"]
type X = { foo: string }
// Options: ["always"]
type X = { foo: string, }
// Options: ["always"]
type X = { foo: string; }
// Options: ["never"]
type X = {
foo: string
}
// Options: ["always"]
type X = {
foo: string,
}
// Options: ["always-multiline"]
type X = { foo: string }
// Options: ["always-multiline"]
type X = {
foo: string,
}
// Options: ["always-multiline"]
type X = {
foo: string;
}
// Options: ["only-multiline"]
type X = { foo: string }
// Options: ["only-multiline"]
type X = {
foo: string
}
// Options: ["only-multiline"]
type X = {
foo: string,
}
// Options: ["only-multiline"]
type X = {
foo: string;
}
// Options: ["never"]
type X = {}
// Options: ["always"]
type X = {}
// Options: ["always-multiline"]
type X = {}
// Options: ["only-multiline"]
type X = {}
// Options: ["never"]
type X = { [key: string]: number }
// Options: ["always"]
type X = { [key: string]: number, }
// Options: ["always"]
type X = { [key: string]: number; }
// Options: ["always-multiline"]
type X = { [key: string]: number }
// Options: ["always-multiline"]
type X = {
[key: string]: number,
}
// Options: ["only-multiline"]
type X = {
[key: string]: number,
}
// Options: ["only-multiline"]
type X = {
[key: string]: number
}
// Options: ["only-multiline"]
type X = { [key: string]: number }
// Options: ["never"]
type X = { [key: string]: number, foo: string }
// Options: ["always"]
type X = { [key: string]: number, foo: string, }
// Options: ["always"]
type X = { [key: string]: number; foo: string; }
// Options: ["always-multiline"]
type X = { [key: string]: number, foo: string }
// Options: ["always-multiline"]
type X = {
[key: string]: number,
foo: string,
}
// Options: ["only-multiline"]
type X = {
[key: string]: number,
foo: string,
}
// Options: ["only-multiline"]
type X = {
[key: string]: number;
foo: string
}
// Options: ["only-multiline"]
type X = { [key: string]: number, foo: string }
// Options: ["never"]
type X = { foo: string, [key: string]: number }
// Options: ["always"]
type X = { foo: string, [key: string]: number, }
// Options: ["always"]
type X = { foo: string; [key: string]: number; }
// Options: ["always-multiline"]
type X = { foo: string, [key: string]: number }
// Options: ["always-multiline"]
type X = {
foo: string,
[key: string]: number,
}
// Options: ["only-multiline"]
type X = {
foo: string,
[key: string]: number,
}
// Options: ["only-multiline"]
type X = {
foo: string;
[key: string]: number
}
// Options: ["only-multiline"]
type X = { foo: string, [key: string]: number }
type X = [string, number]
// Options: ["never"]
type X = [string, number]
// Options: ["never"]
type X = [
string,
number
]
// Options: ["always"]
type X = [string, number,]
// Options: ["always"]
type X = [
string,
number,
]
// Options: ["always-multiline"]
type X = [ foo, string ]
// Options: ["always-multiline"]
type X = [
foo, string,
]
// Options: ["only-multiline"]
type X = [ number, string ]
// Options: ["only-multiline"]
type X = [
number,
string
]
// Options: ["only-multiline"]
type X = [
number,
string,
]
// Options: ["never"]
type X = []
// Options: ["always"]
type X = []
// Options: ["always-multiline"]
type X = []
// Options: ["only-multiline"]
type X = []
generic-spacingThe --fix option on the command line automatically fixes problems reported by this rule.
Enforces consistent spacing within generic type annotation parameters.
This rule takes one argument. If it is 'never' then a problem is raised when there is a space surrounding the generic type parameters. If it is 'always' then a problem is raised when there is no space surrounding the generic type parameters.
The default value is 'never'.
The following patterns are considered problems:
type X = Promise< string>
// Message: There must be no space at start of "Promise" generic type annotation
// Options: ["never"]
type X = Promise< string>
// Message: There must be no space at start of "Promise" generic type annotation
type X = FooBar<string >
// Message: There must be no space at end of "FooBar" generic type annotation
type X = Promise< string >
// Message: There must be no space at start of "Promise" generic type annotation
// Message: There must be no space at end of "Promise" generic type annotation
type X = Promise< (foo), bar, (((baz))) >
// Message: There must be no space at start of "Promise" generic type annotation
// Message: There must be no space at end of "Promise" generic type annotation
// Options: ["always"]
type X = Promise<string >
// Message: There must be a space at start of "Promise" generic type annotation
// Options: ["always"]
type X = FooBar< string>
// Message: There must be a space at end of "FooBar" generic type annotation
// Options: ["always"]
type X = Promise<string>
// Message: There must be a space at start of "Promise" generic type annotation
// Message: There must be a space at end of "Promise" generic type annotation
// Options: ["always"]
type X = Promise<(foo), bar, (((baz)))>
// Message: There must be a space at start of "Promise" generic type annotation
// Message: There must be a space at end of "Promise" generic type annotation
// Options: ["always"]
type X = FooBar< string >
// Message: There must be one space at start of "FooBar" generic type annotation
// Options: ["always"]
type X = FooBar< string >
// Message: There must be one space at end of "FooBar" generic type annotation
// Options: ["always"]
type X = Promise< (foo), bar, (((baz))) >
// Message: There must be one space at start of "Promise" generic type annotation
// Message: There must be one space at end of "Promise" generic type annotation
The following patterns are not considered problems:
type X = Promise<string>
type X = Promise<(string)>
type X = Promise<(foo), bar, (((baz)))>
// Options: ["always"]
type X = Promise< string >
// Options: ["always"]
type X = Promise< (string) >
// Options: ["always"]
type X = Promise< (foo), bar, (((baz))) >
newline-after-flow-annotationThis rule requires an empty line after the Flow annotation.
The rule has a string option:
"always" (default): Enforces that @flow annotations be followed by an empty line, separated by newline (LF)"always-windows": Identical to "always", but will use a CRLF when autofixing"never": Enforces that @flow annotations are not followed by empty lines{
"rules": {
"flowtype/newline-after-flow-annotation": [
2,
"always"
]
}
}
The following patterns are considered problems:
// @flow
import Foo from './foo';
// Message: Expected newline after flow annotation
// Options: ["always"]
// @flow
import Foo from './foo';
// Message: Expected newline after flow annotation
// Options: ["always-windows"]
// @flow
import Foo from './foo';
// Message: Expected newline after flow annotation
// Options: ["never"]
// @flow
// Message: Expected no newline after flow annotation
The following patterns are not considered problems:
// Options: ["always"]
// @flow
import Foo from './foo';
// Options: ["always-windows"]
// @flow
import Foo from './foo';
// Options: ["never"]
// @flow
import Foo from './foo';
no-dupe-keysChecks for duplicate properties in Object annotations.
This rule mirrors ESLint's no-dupe-keys rule.
{
"rules": {
"flowtype/no-dupe-keys": 2
}
}
The following patterns are considered problems:
type f = { a: number, b: string, a: number }
// Message: Duplicate property.
type f = { a: number, b: string, a: string }
// Message: Duplicate property.
type f = { get(key: "a"): string, get(key: "a"): string }
// Message: Duplicate property.
type f = { get(key: 1): string, get(key: 1): string }
// Message: Duplicate property.
type f = { get(key: 1.1): string, get(key: 1.1): string }
// Message: Duplicate property.
type f = { get(key: true): string, get(key: true): string }
// Message: Duplicate property.
type f = { get(key: {a: 1}): string, get(key: {a: 1}):string }
// Message: Duplicate property.
var a = "a"; type f = { get(key: a): string, get(key: a): string }
// Message: Duplicate property.
var b = 1; type f = { get(key: b): string, get(key: b): string }
// Message: Duplicate property.
var c = true; type f = { get(key: c): string, get(key: c): string }
// Message: Duplicate property.
var d = {}; type f = { get(key: d): string, get(key: d): string }
// Message: Duplicate property.
var e = []; type f = { get(key: e): string, get(key: e): string }
// Message: Duplicate property.
var e = [1, "a"]; type f = { get(key: e): string, get(key: e): string }
// Message: Duplicate property.
function fn() {}; type f = { get(key: fn): string, get(key: fn): string }
// Message: Duplicate property.
The following patterns are not considered problems:
type FooType = { a: number, b: string, c: number }
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
type FooType = { a: number, b: string, a: number }
type f = { get(key: "a"): string, get(key: "b"): string }
type f = { get(key: 1): string, get(key: 2): string }
type f = { get(key: 1.1): string, get(key: 1.2): string }
type f = { get(key: true): string, get(key: false): string }
type f = { get(key: ["a", 1]): string, get(key: ["a", 2]): string }
type f = { get(key: ["a", ["b", 1]]): string, get(key: ["a", ["b", 2]]): string }
type f = { a: number, b: string, c: number }
type f = { get(key: "a"): string, get(key: "b"): string }
type f = { get(key: "a"): string, get(key: "a", key2: "b"): string }
type f = { get(key: "a"): string, get(key: 1): string }
type f = { get(key: { a: 1 }): string, get(key: { a: 2 }): string}
var a = {}; var b = {}; type f = { get(key: a): string, get(key: b): string }
var a = 1; var b = 1; type f = { get(key: a): string, get(key: b): string }
no-existential-typeDisallows use of the existential type (*). See more
{
"rules": {
"flowtype/no-existential-type": 2
}
}
The following patterns are considered problems:
type T = *;
// Message: Unexpected use of existential type (*).
type T = U<*, *>;
// Message: Unexpected use of existential type (*).
// Message: Unexpected use of existential type (*).
const f: (*) => null = () => null;
// Message: Unexpected use of existential type (*).
The following patterns are not considered problems:
type T = string | null
no-flow-fix-me-commentsDisallows $FlowFixMe comment suppressions.
This is especially useful as a warning to ensure instances of $FlowFixMe in your codebase get fixed over time.
This rule takes an optional RegExp that comments a text RegExp that makes the supression valid.
{
"rules": {
"flowtype/no-flow-fix-me-comments": [
1,
"TODO\s+[0-9]+"
]
}
}
no-mutable-arrayThe --fix option on the command line automatically fixes problems reported by this rule.
Requires use of $ReadOnlyArray instead of just Array or array shorthand notation. $ReadOnlyArray is immutable array collection type and the superclass of Array and tuple types in Flow. Use of $ReadOnlyArray instead of Array can solve some "problems" in typing with Flow (e.g., 1, 2).
General reasons for using immutable data structures:
Note that initialization of a variable with an empty array is considered valid (e.g., const values: Array<string> = [];). This behavior resembles the behavior of Flow's unsealed objects, as it is assumed that empty array is intended to be mutated.
The following patterns are considered problems:
type X = Array<string>
// Message: Use "$ReadOnlyArray" instead of "Array"
type X = string[]
// Message: Use "$ReadOnlyArray" instead of array shorthand notation
const values: Array<Array<string>> = [];
// Message: Use "$ReadOnlyArray" instead of "Array"
let values: Array<Array<string>>;
// Message: Use "$ReadOnlyArray" instead of "Array"
// Message: Use "$ReadOnlyArray" instead of "Array"
The following patterns are not considered problems:
type X = $ReadOnlyArray<string>
const values: Array<$ReadOnlyArray<string>> = [];
const values: $ReadOnlyArray<string>[] = [];
const values: Array<$ReadOnlyArray<string>> = new Array();
const values: Array<$ReadOnlyArray<string>> = Array();
no-primitive-constructor-typesDisallows use of primitive constructors as types, such as Boolean, Number and String. See more.
{
"rules": {
"flowtype/no-primitive-constructor-types": 2
}
}
The following patterns are considered problems:
type x = Number
// Message: Unexpected use of Number constructor type.
type x = String
// Message: Unexpected use of String constructor type.
type x = Boolean
// Message: Unexpected use of Boolean constructor type.
type x = { a: Number }
// Message: Unexpected use of Number constructor type.
type x = { a: String }
// Message: Unexpected use of String constructor type.
type x = { a: Boolean }
// Message: Unexpected use of Boolean constructor type.
(x: Number) => {}
// Message: Unexpected use of Number constructor type.
(x: String) => {}
// Message: Unexpected use of String constructor type.
(x: Boolean) => {}
// Message: Unexpected use of Boolean constructor type.
The following patterns are not considered problems:
type x = number
type x = string
type x = boolean
type x = { a: number }
type x = { a: string }
type x = { a: boolean }
(x: number) => {}
(x: string) => {}
(x: boolean) => {}
type x = MyNumber
type x = MyString
type x = MyBoolean
no-types-missing-file-annotationDisallows Flow type imports, aliases, and annotations in files missing a valid Flow file declaration (or a @noflow annotation).
{
"rules": {
"flowtype/no-types-missing-file-annotation": 2
}
}
The following patterns are considered problems:
const x: number = 42;
// Message: Type annotations require valid Flow declaration.
type FooType = number;
// Message: Type aliases require valid Flow declaration.
import type A from "a"
// Message: Type imports require valid Flow declaration.
import type {A} from "a"
// Message: Type imports require valid Flow declaration.
import {type A} from "a"
// Message: Type imports require valid Flow declaration.
export type {A} from "a"
// Message: Type exports require valid Flow declaration.
function t<T>(): T{}
// Message: Type annotations require valid Flow declaration.
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
const x: number = 42;
// Message: Type annotations require valid Flow declaration.
The following patterns are not considered problems:
// @flow
const x: number = 42;
/* @flow weak */
type FooType = number;
/* @noflow */
type FooType = number;
/* @noflow */
import type A from "a"
/* @noflow */
import {type A} from "a"
/* @noflow */
export type {A} from "a"
// an unrelated comment
// @flow
export type {A} from "a"
no-unused-expressionsAn extension of ESLint's no-unused-expressions.
This rule ignores type cast expressions, but otherwise behaves the same as ESLint's
no-unused-expressions.
Bare type casts are useful, for example to assert the exhaustiveness of a switch:
type Action
= { type: 'FOO', doFoo: (_: number) => void }
| { type: 'BAR', doBar: (_: string) => void };
type State = { foo: number, bar: string };
function runFooBar(action: Action, state: State): void {
switch (action.type) {
case 'FOO':
doFoo(state.foo);
break;
case 'BAR':
doBar(state.bar);
break;
default:
(action: empty); // type error when `Action` is extended with new types
console.error(`Impossible action: ${action.toString()}`);
}
}
This rule takes the same arguments as ESLint's no-unused-expressions. See
that rule's documentation for details.
The following patterns are considered problems:
foo + 1
// Message: Expected an assignment or function call and instead saw an expression.
The following patterns are not considered problems:
(foo: number)
no-weak-typesWarns against weak type annotations any, Object and Function. These types can cause flow to silently skip over portions of your code, which would have otherwise caused type errors.
This rule optionally takes one argument, an object to configure which type warnings to enable. By default, all of the
warnings are enabled. e.g. to disable the any warning (allowing it to exist in your code), while continuing to warn
about Object and Function:
{
"rules": {
"flowtype/no-weak-types": [2, {
"any": false,
"Object": true,
"Function": true
}]
}
}
// or, the following is equivalent as default is true:
{
"rules": {
"flowtype/no-weak-types": [2, {
"any": false
}]
}
}
The following patterns are considered problems:
function foo(thing): any {}
// Message: Unexpected use of weak type "any"
function foo(thing): Promise<any> {}
// Message: Unexpected use of weak type "any"
function foo(thing): Promise<Promise<any>> {}
// Message: Unexpected use of weak type "any"
function foo(thing): Object {}
// Message: Unexpected use of weak type "Object"
function foo(thing): Promise<Object> {}
// Message: Unexpected use of weak type "Object"
function foo(thing): Promise<Promise<Object>> {}
// Message: Unexpected use of weak type "Object"
function foo(thing): Function {}
// Message: Unexpected use of weak type "Function"
function foo(thing): Promise<Function> {}
// Message: Unexpected use of weak type "Function"
function foo(thing): Promise<Promise<Function>> {}
// Message: Unexpected use of weak type "Function"
(foo: any) => {}
// Message: Unexpected use of weak type "any"
(foo: Function) => {}
// Message: Unexpected use of weak type "Function"
(foo?: any) => {}
// Message: Unexpected use of weak type "any"
(foo?: Function) => {}
// Message: Unexpected use of weak type "Function"
(foo: { a: any }) => {}
// Message: Unexpected use of weak type "any"
(foo: { a: Object }) => {}
// Message: Unexpected use of weak type "Object"
(foo: any[]) => {}
// Message: Unexpected use of weak type "any"
type Foo = any
// Message: Unexpected use of weak type "any"
type Foo = Function
// Message: Unexpected use of weak type "Function"
type Foo = { a: any }
// Message: Unexpected use of weak type "any"
type Foo = { a: Object }
// Message: Unexpected use of weak type "Object"
type Foo = { (a: Object): string }
// Message: Unexpected use of weak type "Object"
type Foo = { (a: string): Function }
// Message: Unexpected use of weak type "Function"
function foo(thing: any) {}
// Message: Unexpected use of weak type "any"
function foo(thing: Object) {}
// Message: Unexpected use of weak type "Object"
var foo: Function
// Message: Unexpected use of weak type "Function"
var foo: Object
// Message: Unexpected use of weak type "Object"
class Foo { props: any }
// Message: Unexpected use of weak type "any"
class Foo { props: Object }
// Message: Unexpected use of weak type "Object"
var foo: any
// Message: Unexpected use of weak type "any"
// Options: [{"Function":false}]
type X = any; type Y = Function; type Z = Object
// Message: Unexpected use of weak type "any"
// Message: Unexpected use of weak type "Object"
// Options: [{"Object":false,"any":false}]
type X = any; type Y = Function; type Z = Object
// Message: Unexpected use of weak type "Function"
The following patterns are not considered problems:
function foo(thing): string {}
function foo(thing): Promise<string> {}
function foo(thing): Promise<Promise<string>> {}
(foo?: string) => {}
(foo: ?string) => {}
(foo: { a: string }) => {}
(foo: { a: ?string }) => {}
(foo: string[]) => {}
type Foo = string
type Foo = { a: string }
type Foo = { (a: string): string }
function foo(thing: string) {}
var foo: string
class Foo { props: string }
// Options: [{"Object":false,"any":false}]
type X = any; type Y = Object
// Options: [{"Function":false}]
type X = Function
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
function foo(thing): Function {}
object-type-delimiterThe --fix option on the command line automatically fixes problems reported by this rule.
Enforces consistent separators between properties in Flow object types.
This rule takes one argument.
If it is 'comma' then a problem is raised when using ; as a separator.
If it is 'semicolon' then a problem is raised when using , as a separator.
The default value is 'comma'.
This rule is ported from babel/flow-object-type, however the default option was changed.
The following patterns are considered problems:
// Options: ["semicolon"]
type Foo = { a: Foo, b: Bar }
// Message: Prefer semicolons to commas in object and class types
// Options: ["comma"]
type Foo = { a: Foo; b: Bar }
// Message: Prefer commas to semicolons in object and class types
// Options: ["semicolon"]
type Foo = { [a: string]: Foo, [b: string]: Bar }
// Message: Prefer semicolons to commas in object and class types
// Options: ["comma"]
type Foo = { [a: string]: Foo; [b: string]: Bar }
// Message: Prefer commas to semicolons in object and class types
// Options: ["semicolon"]
type Foo = { (): Foo, (): Bar }
// Message: Prefer semicolons to commas in object and class types
// Options: ["comma"]
type Foo = { (): Foo; (): Bar }
// Message: Prefer commas to semicolons in object and class types
// Options: ["semicolon"]
declare class Foo { a: Foo, }
// Message: Prefer semicolons to commas in object and class types
// Options: ["comma"]
declare class Foo { a: Foo; }
// Message: Prefer commas to semicolons in object and class types
// Options: ["semicolon"]
declare class Foo { [a: string]: Foo, }
// Message: Prefer semicolons to commas in object and class types
// Options: ["comma"]
declare class Foo { a: Foo; }
// Message: Prefer commas to semicolons in object and class types
// Options: ["semicolon"]
declare class Foo { (): Foo, }
// Message: Prefer semicolons to commas in object and class types
// Options: ["comma"]
declare class Foo { (): Foo; }
// Message: Prefer commas to semicolons in object and class types
// Options: ["semicolon"]
declare class Foo { static (): Foo, }
// Message: Prefer semicolons to commas in object and class types
// Options: ["comma"]
declare class Foo { static (): Foo; }
// Message: Prefer commas to semicolons in object and class types
The following patterns are not considered problems:
// Options: ["semicolon"]
type Foo = { a: Foo; b: Bar }
// Options: ["comma"]
type Foo = { a: Foo, b: Bar }
// Options: ["semicolon"]
type Foo = { [a: string]: Foo; [b: string]: Bar }
// Options: ["comma"]
type Foo = { [a: string]: Foo, [b: string]: Bar }
// Options: ["semicolon"]
type Foo = { (): Foo; (): Bar }
// Options: ["comma"]
type Foo = { (): Foo, (): Bar }
type Foo = { a: Foo, b: Bar }
type Foo = { [a: string]: Foo, [b: string]: Bar }
type Foo = { (): Foo, (): Bar }
// Options: ["semicolon"]
declare class Foo { a: Foo; }
// Options: ["comma"]
declare class Foo { a: Foo, }
// Options: ["semicolon"]
declare class Foo { [a: string]: Foo; }
// Options: ["comma"]
declare class Foo { [a: string]: Foo, }
// Options: ["semicolon"]
declare class Foo { (): Foo; }
// Options: ["comma"]
declare class Foo { (): Foo, }
// Options: ["semicolon"]
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
type Foo = { a: Foo, b: Bar }
require-exact-typeThis rule enforces exact object types.
The rule has one string option:
"always" (default): Report all object type definitions that aren't exact."never": Report all object type definitions that are exact.{
"rules": {
"flowtype/require-exact-type": [
2,
"always"
]
}
}
{
"rules": {
"flowtype/require-exact-type": [
2,
"never"
]
}
}
The following patterns are considered problems:
type foo = {};
// Message: Type identifier 'foo' must be exact.
type foo = { bar: string };
// Message: Type identifier 'foo' must be exact.
// Options: ["always"]
type foo = {};
// Message: Type identifier 'foo' must be exact.
// Options: ["always"]
type foo = { bar: string };
// Message: Type identifier 'foo' must be exact.
// Options: ["never"]
type foo = {| |};
// Message: Type identifier 'foo' must not be exact.
// Options: ["never"]
type foo = {| bar: string |};
// Message: Type identifier 'foo' must not be exact.
The following patterns are not considered problems:
type foo = {| |};
type foo = {| bar: string |};
type foo = number;
// Options: ["always"]
type foo = {| |};
// Options: ["always"]
type foo = {| bar: string |};
// Options: ["always"]
type foo = number;
// Options: ["never"]
type foo = { };
// Options: ["never"]
type foo = { bar: string };
// Options: ["never"]
type foo = number;
require-parameter-typeRequires that all function parameters have type annotations.
You can skip all arrow functions by providing the excludeArrowFunctions option with true.
Alternatively, you can want to exclude only concise arrow functions (e.g. x => x * 2). Provide excludeArrowFunctions with expressionsOnly for this.
{
"rules": {
"flowtype/require-parameter-type": [
2,
{
"excludeArrowFunctions": true
}
]
}
}
{
"rules": {
"flowtype/require-parameter-type": [
2,
{
"excludeArrowFunctions": "expressionsOnly"
}
]
}
}
You can exclude parameters that match a certain regex by using excludeParameterMatch.
{
"rules": {
"flowtype/require-parameter-type": [
2,
{
"excludeParameterMatch": "^_"
}
]
}
}
This excludes all parameters that start with an underscore (_).
The default pattern is a^, which doesn't match anything, i.e., all parameters are checked.
The following patterns are considered problems:
(foo) => {}
// Message: Missing "foo" parameter type annotation.
function x(foo) {}
// Message: Missing "foo" parameter type annotation.
// Options: [{"excludeArrowFunctions":true}]
function x(foo) {}
// Message: Missing "foo" parameter type annotation.
(foo = 'FOO') => {}
// Message: Missing "foo" parameter type annotation.
(...foo) => {}
// Message: Missing "foo" parameter type annotation.
({foo}) => {}
// Message: Missing "{foo}" parameter type annotation.
([foo]) => {}
// Message: Missing "[foo]" parameter type annotation.
({foo = 1} = {}) => {}
// Message: Missing "{foo = 1}" parameter type annotation.
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
// @flow
(foo) => {}
// Message: Missing "foo" parameter type annotation.
// Options: [{"excludeArrowFunctions":"expressionsOnly"}]
(foo) => {}
// Message: Missing "foo" parameter type annotation.
// Options: [{"excludeArrowFunctions":"expressionsOnly"}]
function x(foo) {}
// Message: Missing "foo" parameter type annotation.
// Options: [{"excludeParameterMatch":"^_"}]
(_foo: number, bar) => {}
// Message: Missing "bar" parameter type annotation.
// Options: [{"excludeParameterMatch":"^_"}]
(_foo, bar) => {}
// Message: Missing "bar" parameter type annotation.
The following patterns are not considered problems:
(foo: string) => {}
(foo: string = 'FOO') => {}
(...foo: string) => {}
({foo}: {foo: string}) => {}
([foo]: Array) => {}
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
(foo) => {}
// Options: [{"excludeArrowFunctions":true}]
(foo) => {}
// Options: [{"excludeArrowFunctions":"expressionsOnly"}]
(foo) => 3
// Options: [{"excludeParameterMatch":"^_"}]
(_foo, bar: string) => {}
// Options: [{"excludeParameterMatch":"^_"}]
(_foo: number, bar: string) => {}
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
(foo) => {}
require-return-typeRequires that functions have return type annotation.
You can skip all arrow functions by providing the excludeArrowFunctions option with true.
Alternatively, you can exclude a concise arrow function (e.g. () => 2). Provide excludeArrowFunctions with expressionsOnly for this.
{
"rules": {
"flowtype/require-return-type": [
2,
"always",
{
"excludeArrowFunctions": true
}
]
}
}
{
"rules": {
"flowtype/require-return-type": [
2,
"always",
{
"excludeArrowFunctions": "expressionsOnly"
}
]
}
}
You can exclude or include specific tests with the includeOnlyMatching and excludeMatching rules.
{
"rules": {
"flowtype/require-return-type": [
2,
"always",
{
"includeOnlyMatching": [
"^F.*",
"Ba(r|z)"
]
}
]
}
}
{
"rules": {
"flowtype/require-return-type": [
2,
"always",
{
"excludeMatching": [
"^F.*",
"Ba(r|z)"
]
}
]
}
}
Both rules take an array that can contain either strings or valid RegExp statements.
The following patterns are considered problems:
(foo) => { return "foo"; }
// Message: Missing return type annotation.
// Options: ["always"]
(foo) => { return "foo"; }
// Message: Missing return type annotation.
// Options: ["always"]
(foo) => "foo"
// Message: Missing return type annotation.
(foo) => ({})
// Message: Missing return type annotation.
(foo): undefined => { return; }
// Message: Must not annotate undefined return type.
(foo): void => { return; }
// Message: Must not annotate undefined return type.
(foo): undefined => { return undefined; }
// Message: Must not annotate undefined return type.
(foo): void => { return void 0; }
// Message: Must not annotate undefined return type.
// Options: ["always",{"annotateUndefined":"never"}]
(foo): undefined => { return; }
// Message: Must not annotate undefined return type.
// Options: ["always",{"annotateUndefined":"never"}]
(foo): void => { return; }
// Message: Must not annotate undefined return type.
// Options: ["always",{"annotateUndefined":"always"}]
(foo) => { return; }
// Message: Must annotate undefined return type.
// Options: ["always",{"annotateUndefined":"never"}]
(foo): undefined => { return undefined; }
// Message: Must not annotate undefined return type.
// Options: ["always",{"annotateUndefined":"always"}]
(foo) => { return undefined; }
// Message: Must annotate undefined return type.
// Options: ["always",{"annotateUndefined":"always"}]
(foo) => { return void 0; }
// Message: Must annotate undefined return type.
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
// @flow
(foo) => { return 1; }
// Message: Missing return type annotation.
// Options: ["always",{"annotateUndefined":"always"}]
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
// @flow
(foo) => { return undefined; }
// Message: Must annotate undefined return type.
// Options: ["always"]
async () => { return 2; }
// Message: Missing return type annotation.
// Options: ["always",{"annotateUndefined":"always"}]
async () => {}
// Message: Missing return type annotation.
// Options: ["always",{"annotateUndefined":"always"}]
async function x() {}
// Message: Missing return type annotation.
// Options: ["always",{"annotateUndefined":"always"}]
class Test { constructor() { } }
// Message: Must annotate undefined return type.
class Test { foo() { return 42; } }
// Message: Missing return type annotation.
class Test { foo = () => { return 42; } }
// Message: Missing return type annotation.
class Test { foo = () => 42; }
// Message: Missing return type annotation.
// Options: ["always"]
async () => { return; }
// Message: Missing return type annotation.
// Options: ["always"]
function* x() {}
// Message: Missing return type annotation.
// Options: ["always",{"excludeArrowFunctions":"expressionsOnly"}]
() => { return 3; }
// Message: Missing return type annotation.
// Options: ["always",{"excludeArrowFunctions":"expressionsOnly"}]
async () => { return 4; }
// Message: Missing return type annotation.
// Options: ["always",{"includeOnlyMatching":["bar"]}]
function foo() { return 42; }
function bar() { return 42; }
// Message: Missing return type annotation.
// Options: ["always",{"includeOnlyMatching":["bar"]}]
const foo = () => { return 42; };
const bar = () => { return 42; }
// Message: Missing return type annotation.
The following patterns are not considered problems:
return;
(foo): string => {}
// Options: ["always"]
(foo): string => {}
(foo) => { return; }
(foo): Object => ( {} )
(foo) => { return undefined; }
(foo) => { return void 0; }
// Options: ["always",{"annotateUndefined":"always"}]
(foo): undefined => { return; }
// Options: ["always",{"annotateUndefined":"always"}]
(foo): void => { return; }
// Options: ["always",{"annotateUndefined":"never"}]
(foo) => { return; }
// Options: ["always",{"annotateUndefined":"never"}]
(foo) => { return undefined; }
// Options: ["always",{"annotateUndefined":"never"}]
(foo) => { return void 0; }
// Options: ["always",{"annotateUndefined":"always"}]
(foo): undefined => { return undefined; }
// Options: ["always",{"annotateUndefined":"always"}]
(foo): void => { return void 0; }
// Options: ["always"]
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
(foo) => { return 1; }
// Options: ["always",{"annotateUndefined":"always"}]
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
(foo) => { return undefined; }
// Options: ["always",{"annotateUndefined":"always"}]
async function doThing(): Promise<void> {}
// Options: ["always",{"annotateUndefined":"always"}]
function* doThing(): Generator<number, void, void> { yield 2; }
// Options: ["always",{"annotateUndefined":"always","excludeMatching":["constructor"]}]
class Test { constructor() { } }
class Test { constructor() { } }
// Options: ["always",{"excludeMatching":["foo"]}]
class Test { foo() { return 42; } }
// Options: ["always",{"excludeMatching":["foo"]}]
class Test { foo = () => { return 42; } }
// Options: ["always",{"excludeMatching":["foo"]}]
class Test { foo = () => 42; }
class Test { foo = (): number => { return 42; } }
class Test { foo = (): number => 42; }
async (foo): Promise<number> => { return 3; }
// Options: ["always",{"excludeArrowFunctions":true}]
() => 3
// Options: ["always",{"excludeArrowFunctions":true}]
() => { return 4; }
// Options: ["always",{"excludeArrowFunctions":true}]
() => undefined
// Options: ["always",{"annotateUndefined":"always","excludeArrowFunctions":true}]
() => undefined
// Options: ["always",{"annotateUndefined":"always","excludeArrowFunctions":true}]
() => { return undefined; }
// Options: ["always",{"excludeArrowFunctions":"expressionsOnly"}]
() => 3
// Options: ["always",{"excludeArrowFunctions":"expressionsOnly"}]
async () => 3
// Options: ["always",{"excludeMatching":["foo"]}]
function foo() { return 42; }
// Options: ["always",{"includeOnlyMatching":["bar"]}]
function foo() { return 42; }
// Options: ["always",{"excludeMatching":["bar"]}]
function foo(): number { return 42; }
function bar() { return 42; }
// Options: ["always",{"includeOnlyMatching":["foo","baz"]}]
function foo(): number { return 42; }
function bar() { return 42; }
// Options: ["always",{"excludeMatching":["^b.*","qux"]}]
function foo(): number { return 42; }
function bar() { return 42; }
// Options: ["always",{"includeOnlyMatching":["^f.*"]}]
function foo(): number { return 42; }
function bar() { return 42; }
require-types-at-topRequires all type declarations to be at the top of the file, after any import declarations.
The rule has a string option:
"never""always"The default value is "always".
require-valid-file-annotationThis rule validates Flow file annotations.
This rule can optionally report missing or missed placed annotations, common typos (e.g. // @floww), and enforce a consistant annotation style.
The rule has a string option:
"never" (default): Never report files that are missing an @flow annotation."always": Always report files that are missing an @flow annotationThis rule has an object option:
"annotationStyle" - Enforce a consistant file annotation style.
"none" (default): Either annotation style is accepted."line": Require single line annotations (i.e. // @flow)."block": Require block annotations (i.e. /* @flow */).{
"rules": {
"flowtype/require-valid-file-annotation": [
2,
"always"
]
}
}
{
"rules": {
"flowtype/require-valid-file-annotation": [
2,
"always", {
"annotationStyle": "block"
}
]
}
}
The following patterns are considered problems:
;// @flow
// Message: Flow file annotation not at the top of the file.
;
// @flow
// Message: Flow file annotation not at the top of the file.
// @Flow
// Message: Malformed Flow file annotation.
// @NoFlow
// Message: Malformed Flow file annotation.
// @Noflow
// Message: Malformed Flow file annotation.
// @floweeeeeee
// Message: Misspelled or malformed Flow file annotation.
// @nofloweeeeeee
// Message: Misspelled or malformed Flow file annotation.
// Options: ["always"]
a;
// Message: Flow file annotation is missing.
// Options: ["always",{"annotationStyle":"line"}]
/* @flow */
// Message: Flow file annotation style must be `// @flow`
// Options: ["always",{"annotationStyle":"block"}]
// @flow
// Message: Flow file annotation style must be `/* @flow */`
// Options: ["always",{"annotationStyle":"line"}]
/* @noflow */
// Message: Flow file annotation style must be `// @noflow`
// Options: ["always",{"annotationStyle":"block"}]
// @noflow
// Message: Flow file annotation style must be `/* @noflow */`
// Options: ["always"]
a;
// Message: Flow file annotation is missing.
// Options: ["always",{"annotationStyle":"block"}]
a;
// Message: Flow file annotation is missing.
The following patterns are not considered problems:
a;
// @flow
a;
//@flow
a;
//**@flow
a;
/* foo @flow bar */
a;
// @flow
a;
// @flow
// @FLow
// @noflow
a;
// Options: ["always"]
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
a;
// Options: ["always",{"annotationStyle":"line"}]
// @flow
// Options: ["never",{"annotationStyle":"none"}]
// @function
// Options: ["never"]
// @fixable
// Options: ["always",{"annotationStyle":"block"}]
/* @flow */
require-variable-typeRequires that all variable declarators have type annotations.
You can exclude variables that match a certain regex by using excludeVariableMatch.
This excludes all parameters that start with an underscore (_).
The default pattern is a^, which doesn't match anything, i.e., all parameters are checked.
{
"rules": {
"flowtype/require-variable-type": [
2,
{
"excludeVariableMatch": "^_"
}
]
}
}
You can choose specific variable types (var, let, and const) to ignore using excludeVariableTypes.
This excludes var and let declarations from needing type annotations, but forces const declarations to have it.
By default, all declarations are checked.
{
"rules": {
"flowtype/require-variable-type": [
2,
{
"excludeVariableTypes": {
"var": true,
"let": true,
"const": false,
}
}
]
}
}
The following patterns are considered problems:
var foo = "bar"
// Message: Missing "foo" variable type annotation.
var foo : string = "bar", bar = 1
// Message: Missing "bar" variable type annotation.
// Options: [{"excludeVariableMatch":"^_"}]
var _foo = "bar", bar = 1
// Message: Missing "bar" variable type annotation.
// Options: [{"excludeVariableTypes":{"let":false,"var":true}}]
var foo = "bar", bar = 1; const oob : string = "oob"; let hey = "yah"
// Message: Missing "hey" variable type annotation.
The following patterns are not considered problems:
var foo : string = "bar"
var foo : string = "bar", bar : number = 1
// Options: [{"excludeVariableMatch":"^_"}]
var _foo = "bar", bar : number = 1
// Options: [{"excludeVariableTypes":{"var":true}}]
var foo = "bar", bar = 1
// Options: [{"excludeVariableTypes":{"let":true,"var":true}}]
var foo = "bar", bar = 1; const oob : string = "oob"; let hey = "yah"
semiThe --fix option on the command line automatically fixes problems reported by this rule.
Enforces consistent use of semicolons after type aliases.
This rule takes one argument. If it is 'never' then a problem is raised when there is a semicolon after a type alias. If it is 'always' then a problem is raised when there is no semicolon after a type alias.
The default value is 'always'.
The following patterns are considered problems:
// Options: []
type FooType = {}
// Message: Missing semicolon.
// Options: ["always"]
type FooType = {}
// Message: Missing semicolon.
// Options: ["never"]
type FooType = {};
// Message: Extra semicolon.
The following patterns are not considered problems:
type FooType = {};
// Options: ["always"]
type FooType = {};
// Options: ["always"]
type FooType = { a: number;
b: string;
};
// Options: ["never"]
type FooType = { a: number;
b: string;
}
// Options: ["never"]
type FooType = {}
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
type FooType = {}
sort-keysThe --fix option on the command line automatically fixes problems reported by this rule.
Enforces sorting of Object annotations.
This rule mirrors ESlint's sort-keys rule.
The first option specifies sort order.
"asc" (default) - enforce ascending sort order."desc" - enforce descending sort order.The second option takes an object with two possible properties.
caseSensitive - if true, enforce case-sensitive sort order. Default is true.natural - if true, enforce natural sort order. Default is false.{
"rules": {
"flowtype/sort-keys": [
2,
"asc", {
"caseSensitive": true,
"natural": false
}
]
}
}
The following patterns are considered problems:
type FooType = { a: number, c: number, b: string }
// Message: Expected type annotations to be in ascending order. "b" should be before "c".
type FooType = { a: number, b: number, C: number }
// Message: Expected type annotations to be in ascending order. "C" should be before "b".
type FooType = { 1: number, 2: number, 10: number }
// Message: Expected type annotations to be in ascending order. "10" should be before "2".
// Options: ["desc"]
type FooType = { a: number, b: number }
// Message: Expected type annotations to be in descending order. "b" should be before "a".
// Options: ["desc"]
type FooType = { C: number, b: number, a: string }
// Message: Expected type annotations to be in descending order. "b" should be before "C".
// Options: ["desc"]
type FooType = { 10: number, 2: number, 1: number }
// Message: Expected type annotations to be in descending order. "2" should be before "10".
// Options: ["asc",{"caseSensitive":false}]
type FooType = { a: number, c: number, C: number, b: string }
// Message: Expected type annotations to be in insensitive ascending order. "b" should be before "C".
// Options: ["asc",{"caseSensitive":false}]
type FooType = { a: number, C: number, c: number, b: string }
// Message: Expected type annotations to be in insensitive ascending order. "b" should be before "c".
// Options: ["asc",{"natural":true}]
type FooType = { 1: number, 10: number, 2: boolean }
// Message: Expected type annotations to be in natural ascending order. "2" should be before "10".
type FooType = { a: number, c: number, b: string }
// Message: Expected type annotations to be in ascending order. "b" should be before "c".
type FooType = {
a: number,
c: number,
b: string,
}
// Message: Expected type annotations to be in ascending order. "b" should be before "c".
type FooType = {
+a: number,
c: number,
b: string,
}
// Message: Expected type annotations to be in ascending order. "b" should be before "c".
type FooType = {
-a: number,
c: number,
b: string,
}
// Message: Expected type annotations to be in ascending order. "b" should be before "c".
type FooType = {
a?: number,
c: ?number,
b: string,
}
// Message: Expected type annotations to be in ascending order. "b" should be before "c".
type FooType = {
a: (number) => void,
c: number,
b: (param: string) => number,
}
// Message: Expected type annotations to be in ascending order. "b" should be before "c".
type FooType = {
a: number | string | boolean,
c: number,
b: (param: string) => number,
}
// Message: Expected type annotations to be in ascending order. "b" should be before "c".
type FooType = {
c: number,
a: number | string | boolean,
b: (param: string) => number,
}
// Message: Expected type annotations to be in ascending order. "a" should be before "c".
type FooType = {
c: {
z: number,
x: string,
y: boolean,
},
a: number | string | boolean,
b: (param: string) => number,
}
// Message: Expected type annotations to be in ascending order. "x" should be before "z".
// Message: Expected type annotations to be in ascending order. "a" should be before "c".
type FooType = {
c: {
z: {
j: string,
l: number,
k: boolean,
},
x: string,
y: boolean,
},
a: number | string | boolean,
b: (param: string) => number,
}
// Message: Expected type annotations to be in ascending order. "k" should be before "l".
// Message: Expected type annotations to be in ascending order. "x" should be before "z".
// Message: Expected type annotations to be in ascending order. "a" should be before "c".
type FooType = {
+c: number,
-b: number,
a: number,
}
// Message: Expected type annotations to be in ascending order. "b" should be before "c".
// Message: Expected type annotations to be in ascending order. "a" should be before "b".
type FooType = {|
+c: number,
-b: number,
a: number,
|}
// Message: Expected type annotations to be in ascending order. "b" should be before "c".
// Message: Expected type annotations to be in ascending order. "a" should be before "b".
The following patterns are not considered problems:
type FooType = { a: number }
type FooType = { a: number, b: number, c: (boolean | number) }
type FooType = { C: number, a: string, b: foo }
type FooType = { 1: number, 10: number, 2: boolean }
// Options: ["desc"]
type FooType = { c: number, b: number, a: number }
// Options: ["desc"]
type FooType = { b: string, a: {}, C: number }
// Options: ["desc"]
type FooType = { 2: number, 10: number, 1: boolean }
// Options: ["asc",{"caseSensitive":false}]
type FooType = { a: number, b: number, c: number, C: number }
// Options: ["asc",{"caseSensitive":false}]
type FooType = { a: number, b: number, C: number, c: number }
// Options: ["asc",{"natural":true}]
type FooType = { 1:number, 2: number, 10: number }
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
type FooType = { b: number, a: number }
space-after-type-colonThe --fix option on the command line automatically fixes problems reported by this rule.
Enforces consistent spacing after the type annotation colon.
This rule has a string argument.
"always" (default): Require a space after the type annotation colon (e.g. foo: BarType)."never": Require no spaces after the type annotation colon (e.g. foo:BarType).This rule has an option object.
"allowLineBreak" - Allow a line break to count as a space following the annotation colon.
"true": Enable"false": Disable{ "rules": { "flowtype/space-after-type-colon": [ 2, "always", { "allowLineBreak": false } ] } }
The following patterns are considered problems:
// Options: ["never"]
(foo: string) => {}
// Message: There must be no space after "foo" parameter type annotation colon.
// Options: ["always"]
(foo: string) => {}
// Message: There must be 1 space after "foo" parameter type annotation colon.
// Options: ["always"]
(foo:(() => void)) => {}
// Message: There must be a space after "foo" parameter type annotation colon.
// Options: ["never"]
(foo: (() => void)) => {}
// Message: There must be no space after "foo" parameter type annotation colon.
// Options: ["always"]
(foo: (() => void)) => {}
// Message: There must be 1 space after "foo" parameter type annotation colon.
({ lorem, ipsum, dolor } : SomeType) => {}
// Message: There must be 1 space after "{ lorem, ipsum, dolor }" parameter type annotation colon.
(foo:{ a: string, b: number }) => {}
// Message: There must be a space after "foo" parameter type annotation colon.
({ a, b } :{ a: string, b: number }) => {}
// Message: There must be a space after "{ a, b }" parameter type annotation colon.
([ a, b ] :string[]) => {}
// Message: There must be a space after "[ a, b ]" parameter type annotation colon.
(i?:number) => {}
// Message: There must be a space after "i" parameter type annotation colon.
(i?: number) => {}
// Message: There must be 1 space after "i" parameter type annotation colon.
// Options: ["never"]
(i?: number) => {}
// Message: There must be no space after "i" parameter type annotation colon.
(foo:
{ a: string, b: number }) => {}
// Message: There must not be a line break after "foo" parameter type annotation colon.
(foo:
{ a: string, b: number }) => {}
// Message: There must not be a line break after "foo" parameter type annotation colon.
(foo:
{ a: string, b: number }) => {}
// Message: There must not be a line break after "foo" parameter type annotation colon.
// Options: ["always"]
():Object => {}
// Message: There must be a space after return type colon.
// Options: ["never"]
(): Object => {}
// Message: There must be no space after return type colon.
// Options: ["always"]
(): Object => {}
// Message: There must be 1 space after return type colon.
// Options: ["always"]
():(() => void) => {}
// Message: There must be a space after return type colon.
// Options: ["never"]
(): (() => void) => {}
// Message: There must be no space after return type colon.
// Options: ["always"]
(): (() => void) => {}
// Message: There must be 1 space after return type colon.
// Options: ["never"]
export default function (foo: string) {}
// Message: There must be no space after "foo" parameter type annotation colon.
// Options: ["never"]
function foo (foo: string) {}
// Message: There must be no space after "foo" parameter type annotation colon.
// Options: ["always"]
(foo:string) => {}
// Message: There must be a space after "foo" parameter type annotation colon.
function foo (foo:string) {}
// Message: There must be a space after "foo" parameter type annotation colon.
async function foo({ lorem, ipsum, dolor }:SomeType) {}
// Message: There must be a space after "{ lorem, ipsum, dolor }" parameter type annotation colon.
function x(i?:number) {}
// Message: There must be a space after "i" parameter type annotation colon.
function x(i?: number) {}
// Message: There must be 1 space after "i" parameter type annotation colon.
// Options: ["never"]
function x(i?: number) {}
// Message: There must be no space after "i" parameter type annotation colon.
function a():x {}
// Message: There must be a space after return type colon.
// Options: ["always"]
function a(): x {}
// Message: There must be 1 space after return type colon.
// Options: ["never"]
function a(): x {}
// Message: There must be no space after return type colon.
type X = (foo:number) => string
// Message: There must be a space after "foo" parameter type annotation colon.
// Options: ["never"]
type X = (foo: number) => string
// Message: There must be no space after "foo" parameter type annotation colon.
type X = (foo: number) => string
// Message: There must be 1 space after "foo" parameter type annotation colon.
type X = (foo:?number) => string
// Message: There must be a space after "foo" parameter type annotation colon.
type X = (foo:(number)) => string
// Message: There must be a space after "foo" parameter type annotation colon.
type X = (foo:((number))) => string
// Message: There must be a space after "foo" parameter type annotation colon.
type X = (foo: ((number))) => string
// Message: There must be 1 space after "foo" parameter type annotation colon.
// Options: ["never"]
type X = (foo: ((number))) => string
// Message: There must be no space after "foo" parameter type annotation colon.
type X = (foo:?(number)) => string
// Message: There must be a space after "foo" parameter type annotation colon.
type TArrayPredicate = (el: T, i?:number) => boolean
// Message: There must be a space after "i" parameter type annotation colon.
type TArrayPredicate = (el: T, i?: number) => boolean
// Message: There must be 1 space after "i" parameter type annotation colon.
// Options: ["never"]
type TArrayPredicate = (el:T, i?: number) => boolean
// Message: There must be no space after "i" parameter type annotation colon.
class X { foo:string }
// Message: There must be a space after "foo" class property type annotation colon.
// Options: ["never"]
class X { foo: string }
// Message: There must be no space after "foo" class property type annotation colon.
class X { foo:?string }
// Message: There must be a space after "foo" class property type annotation colon.
// Options: ["never"]
class X { foo: ?string }
// Message: There must be no space after "foo" class property type annotation colon.
class X { static foo:number }
// Message: There must be a space after "foo" class property type annotation colon.
// Options: ["never"]
class X { static foo: number }
// Message: There must be no space after "foo" class property type annotation colon.
class X { static foo :number }
// Message: There must be a space after "foo" class property type annotation colon.
// Options: ["never"]
class X { static foo : number }
// Message: There must be no space after "foo" class property type annotation colon.
declare class X { static foo:number }
// Message: There must be a space after "foo" type annotation colon.
// Options: ["never"]
declare class X { static foo: number }
// Message: There must be no space after "foo" type annotation colon.
declare class X { static foo :number }
// Message: There must be a space after "foo" type annotation colon.
// Options: ["never"]
declare class X { static foo : number }
// Message: There must be no space after "foo" type annotation colon.
class X { +foo:string }
// Message: There must be a space after "foo" class property type annotation colon.
class X { +foo: string }
// Message: There must be 1 space after "foo" class property type annotation colon.
// Options: ["never"]
class X { +foo: string }
// Message: There must be no space after "foo" class property type annotation colon.
class X { static +foo:string }
// Message: There must be a space after "foo" class property type annotation colon.
class X { static +foo: string }
// Message: There must be 1 space after "foo" class property type annotation colon.
// Options: ["never"]
class X { static +foo: string }
// Message: There must be no space after "foo" class property type annotation colon.
type X = { foo:string }
// Message: There must be a space after "foo" type annotation colon.
// Options: ["always"]
type X = { foo:string }
// Message: There must be a space after "foo" type annotation colon.
// Options: ["never"]
type X = { foo: string }
// Message: There must be no space after "foo" type annotation colon.
type X = { foo: string }
// Message: There must be 1 space after "foo" type annotation colon.
type X = { foo?:string }
// Message: There must be a space after "foo" type annotation colon.
// Options: ["never"]
type X = { foo?: string }
// Message: There must be no space after "foo" type annotation colon.
type X = { foo?:?string }
// Message: There must be a space after "foo" type annotation colon.
type X = { foo?: ?string }
// Message: There must be 1 space after "foo" type annotation colon.
type Foo = { barType:(string | () => void) }
// Message: There must be a space after "barType" type annotation colon.
type Foo = { barType:(((string | () => void))) }
// Message: There must be a space after "barType" type annotation colon.
// Options: ["never"]
type Foo = { barType: (string | () => void) }
// Message: There must be no space after "barType" type annotation colon.
type Foo = { barType: (string | () => void) }
// Message: There must be 1 space after "barType" type annotation colon.
type Foo = { barType: ((string | () => void)) }
// Message: There must be 1 space after "barType" type annotation colon.
type X = { get:() => A; }
// Message: There must be a space after "get" type annotation colon.
type X = { get:<X>() => A; }
// Message: There must be a space after "get" type annotation colon.
// Options: ["never"]
type X = { get: () => A; }
// Message: There must be no space after "get" type annotation colon.
// Options: ["never"]
type X = { get: <X>() => A; }
// Message: There must be no space after "get" type annotation colon.
type X = { get: () => A; }
// Message: There must be 1 space after "get" type annotation colon.
type X = { get: <X>() => A; }
// Message: There must be 1 space after "get" type annotation colon.
type X = { +foo:string }
// Message: There must be a space after "foo" type annotation colon.
type X = { +foo: string }
// Message: There must be 1 space after "foo" type annotation colon.
// Options: ["never"]
type X = { +foo: string }
// Message: There must be no space after "foo" type annotation colon.
type X = { +foo?:string }
// Message: There must be a space after "foo" type annotation colon.
type X = { +foo?: string }
// Message: There must be 1 space after "foo" type annotation colon.
// Options: ["never"]
type X = { +foo?: string }
// Message: There must be no space after "foo" type annotation colon.
// Options: ["always"]
type X = { [a:b]: c }
// Message: There must be a space after type annotation colon.
// Options: ["never"]
type X = { [a: b]:c }
// Message: There must be no space after type annotation colon.
// Options: ["always"]
type X = { [a: b]: c }
// Message: There must be 1 space after type annotation colon.
// Options: ["always"]
type X = { +[a:b]: c }
// Message: There must be a space after type annotation colon.
// Options: ["never"]
type X = { +[a: b]:c }
// Message: There must be no space after type annotation colon.
// Options: ["always"]
type X = { +[a: b]: c }
// Message: There must be 1 space after type annotation colon.
// Options: ["always"]
type X = { [a: b]:c }
// Message: There must be a space after type annotation colon.
// Options: ["never"]
type X = { [a:b]: c }
// Message: There must be no space after type annotation colon.
// Options: ["always"]
type X = { [a: b]: c }
// Message: There must be 1 space after type annotation colon.
// Options: ["always"]
type X = { [a:b]:c }
// Message: There must be a space after type annotation colon.
// Message: There must be a space after type annotation colon.
// Options: ["never"]
type X = { [a: b]: c }
// Message: There must be no space after type annotation colon.
// Message: There must be no space after type annotation colon.
// Options: ["always"]
type X = { [a: b]: c }
// Message: There must be 1 space after type annotation colon.
// Message: There must be 1 space after type annotation colon.
// Options: ["always"]
type X = { [a:(b)]:(c) }
// Message: There must be a space after type annotation colon.
// Message: There must be a space after type annotation colon.
// Options: ["never"]
type X = { [a: (b)]: (c) }
// Message: There must be no space after type annotation colon.
// Message: There must be no space after type annotation colon.
// Options: ["never"]
const x = ({}: {})
// Message: There must be no space after type cast colon.
// Options: ["always"]
const x = ({}:{})
// Message: There must be a space after type cast colon.
// Options: ["always"]
const x = ({}: {})
// Message: There must be 1 space after type cast colon.
// Options: ["never"]
((x): (string))
// Message: There must be no space after type cast colon.
// Options: ["always"]
((x):(string))
// Message: There must be a space after type cast colon.
// Options: ["always"]
((x): (string))
// Message: There must be 1 space after type cast colon.
// Options: ["always"]
const x:number = 7;
// Message: There must be a space after const type annotation colon.
// Options: ["always"]
let x:number = 42;
// Message: There must be a space after let type annotation colon.
// Options: ["always"]
var x:number = 42;
// Message: There must be a space after var type annotation colon.
The following patterns are not considered problems:
(foo) => {}
(foo: string) => {}
(foo: (string|number)) => {}
// Options: ["never"]
(foo:string) => {}
// Options: ["always"]
(foo: string) => {}
// Options: ["never"]
(foo:(() => void)) => {}
// Options: ["always"]
(foo: (() => void)) => {}
({ lorem, ipsum, dolor }: SomeType) => {}
(foo: { a: string, b: number }) => {}
({ a, b }: ?{ a: string, b: number }) => {}
([ a, b ]: string[]) => {}
(i?: number) => {}
// Options: ["never"]
(i?:number) => {}
// Options: ["always",{"allowLineBreak":true}]
(foo:
{ a: string, b: number }) => {}
// Options: ["always",{"allowLineBreak":true}]
(foo:
{ a: string, b: number }) => {}
// Options: ["never"]
():Object => {}
// Options: ["always"]
(): Object => {}
// Options: ["never"]
():(number | string) => {}
// Options: ["always"]
(): (number | string) => {}
// Options: ["never"]
():number|string => {}
// Options: ["always"]
(): number|string => {}
// Options: ["never"]
():(() => void) => {}
// Options: ["always"]
(): (() => void) => {}
// Options: ["never"]
():( () => void ) => {}
// Options: ["always"]
(): ( () => void ) => {}
(): { a: number, b: string } => {}
// Options: ["never"]
() :{ a:number, b:string } => {}
function x(foo: string) {}
class Foo { constructor(foo: string) {} }
// Options: ["never"]
function x(foo:string) {}
// Options: ["never"]
class Foo { constructor(foo:string) {} }
async function foo({ lorem, ipsum, dolor }: SomeType) {}
function x({ a, b }: { a: string, b: number }) {}
function x(i?: number) {}
// Options: ["never"]
function x(i?:number) {}
function a(): x {}
// Options: ["never"]
function a():x {}
function a(): (number | string) {}
// Options: ["never"]
function a() :(number | string) {}
type X = (foo: number) => string;
type X = (foo : number) => string;
type X = (foo: ?number) => string;
type X = (foo? : ?number) => string;
type X = (foo: ?{ x: number }) => string;
// Options: ["never"]
type X = (foo:number) => string;
// Options: ["never"]
type X = (foo:?{ x:number }) => string;
type X = (foo: (number)) => string
type X = (foo: ((number))) => string
// Options: ["never"]
type X = (foo:((number))) => string
type X = ?(foo: ((number))) => string
// Options: ["never"]
type X = ?(foo:((number))) => string
type TArrayPredicate = (el: T, i?: number) => boolean
// Options: ["never"]
type TArrayPredicate = (el:T, i?:number) => boolean
type X = (number) => string;
type X = (?number) => string;
type X = number => string;
type X = ?number => string;
type X = ({ foo: bar }) => string;
// Options: ["always"]
type X = (number) => string;
// Options: ["always"]
type X = (?number) => string;
// Options: ["always"]
type X = number => string;
// Options: ["always"]
type X = ?number => string;
// Options: ["always"]
type X = ({ foo: bar }) => string;
class Foo { bar }
class Foo { bar = 3 }
class Foo { bar: string }
class Foo { bar: ?string }
// Options: ["never"]
class Foo { bar:string }
// Options: ["never"]
class Foo { bar:?string }
class X { static foo : number }
// Options: ["never"]
class X { static foo :number }
declare class X { static foo : number }
// Options: ["never"]
declare class X { static foo :number }
class X { +foo: string }
class X { static +foo: string }
// Options: ["never"]
class X { +foo:string }
// Options: ["never"]
class X { static +foo:string }
type X = { foo: string }
// Options: ["never"]
type X = { foo:string }
type X = { foo?: string }
type X = { foo?: ?string }
// Options: ["never"]
type X = { foo?:?string }
type Foo = { barType: (string | () => void) }
type Foo = { barType: ((string | () => void)) }
// Options: ["never"]
type Foo = { barType:(string | () => void) }
// Options: ["never"]
type Foo = { barType:((string | () => void)) }
type X = { get(): A; }
type X = { get<X>(): A; }
// Options: ["never"]
type X = { get(): A; }
// Options: ["never"]
type X = { get<X>(): A; }
type X = { get: () => A; }
type X = { get: <X>() => A; }
// Options: ["never"]
type X = { get:() => A; }
// Options: ["never"]
type X = { get:<X>() => A; }
type X = { +foo: string }
type X = { +foo?: string }
// Options: ["never"]
type X = { +foo:string }
// Options: ["never"]
type X = { +foo?:string }
// Options: ["always"]
type X = { [a: b]: c }
// Options: ["never"]
type X = { [a:b]:c }
// Options: ["always"]
type X = { +[a: b]: c }
// Options: ["never"]
type X = { +[a:b]:c }
// Options: ["always"]
type X = { [string]: c }
// Options: ["never"]
type X = { [string]:c }
// Options: ["never"]
const x = ({}:{})
// Options: ["always"]
const x = ({}: {})
// Options: ["never"]
((x):(string))
// Options: ["always"]
((x): (string))
// Options: ["always"]
const x: number = 7;
// Options: ["always"]
let x: number = 42;
// Options: ["always"]
var x: number = 42;
space-before-generic-bracketThe --fix option on the command line automatically fixes problems reported by this rule.
Enforces consistent spacing before the opening < of generic type annotation parameters.
This rule takes one argument. If it is 'never' then a problem is raised when there is a space before the <. If it is 'always' then a problem is raised when there is no space before the <.
The default value is 'never'.
The following patterns are considered problems:
type X = Promise <string>
// Message: There must be no space before "Promise" generic type annotation bracket
// Options: ["never"]
type X = Promise <string>
// Message: There must be no space before "Promise" generic type annotation bracket
type X = Promise <string>
// Message: There must be no space before "Promise" generic type annotation bracket
// Options: ["always"]
type X = Promise<string>
// Message: There must be a space before "Promise" generic type annotation bracket
// Options: ["always"]
type X = Promise <string>
// Message: There must be one space before "Promise" generic type annotation bracket
The following patterns are not considered problems:
type X = Promise<string>
// Options: ["always"]
type X = Promise <string>
space-before-type-colonThe --fix option on the command line automatically fixes problems reported by this rule.
Enforces consistent spacing before the type annotation colon.
This rule takes one argument. If it is 'always' then a problem is raised when there is no space before the type annotation colon. If it is 'never' then a problem is raised when there is a space before the type annotation colon. The default value is 'never'.
The following patterns are considered problems:
// Options: ["never"]
(foo : string) => {}
// Message: There must be no space before "foo" parameter type annotation colon.
// Options: ["never"]
(foo ? : string) => {}
// Message: There must be no space before "foo" parameter type annotation colon.
// Options: ["always"]
(foo: string) => {}
// Message: There must be a space before "foo" parameter type annotation colon.
// Options: ["always"]
(foo : string) => {}
// Message: There must be 1 space before "foo" parameter type annotation colon.
// Options: ["always"]
(foo?: string) => {}
// Message: There must be a space before "foo" parameter type annotation colon.
// Options: ["always"]
(foo ? : string) => {}
// Message: There must be 1 space before "foo" parameter type annotation colon.
// Options: ["always"]
(foo ?: string) => {}
// Message: There must be a space before "foo" parameter type annotation colon.
({ lorem, ipsum, dolor } : SomeType) => {}
// Message: There must be no space before "{ lorem, ipsum, dolor }" parameter type annotation colon.
(foo : { a: string, b: number }) => {}
// Message: There must be no space before "foo" parameter type annotation colon.
({ a, b } : { a: string, b: number }) => {}
// Message: There must be no space before "{ a, b }" parameter type annotation colon.
([ a, b ] : string[]) => {}
// Message: There must be no space before "[ a, b ]" parameter type annotation colon.
() : x => {}
// Message: There must be no space before return type colon.
// Options: ["always"]
(): x => {}
// Message: There must be a space before return type colon.
// Options: ["always"]
() : x => {}
// Message: There must be 1 space before return type colon.
function x(foo : string) {}
// Message: There must be no space before "foo" parameter type annotation colon.
// Options: ["always"]
function x(foo: string) {}
// Message: There must be a space before "foo" parameter type annotation colon.
var x = function (foo : string) {}
// Message: There must be no space before "foo" parameter type annotation colon.
// Options: ["always"]
var x = function (foo: string) {}
// Message: There must be a space before "foo" parameter type annotation colon.
class Foo { constructor(foo : string ) {} }
// Message: There must be no space before "foo" parameter type annotation colon.
// Options: ["always"]
class Foo { constructor(foo: string ) {} }
// Message: There must be a space before "foo" parameter type annotation colon.
async function foo({ lorem, ipsum, dolor } : SomeType) {}
// Message: There must be no space before "{ lorem, ipsum, dolor }" parameter type annotation colon.
function a() : x {}
// Message: There must be no space before return type colon.
// Options: ["always"]
function a(): x {}
// Message: There must be a space before return type colon.
// Options: ["always"]
function a() : x {}
// Message: There must be 1 space before return type colon.
type X = (foo :string) => string;
// Message: There must be no space before "foo" parameter type annotation colon.
// Options: ["always"]
type X = (foo:string) => string;
// Message: There must be a space before "foo" parameter type annotation colon.
// Options: ["always"]
type X = (foo :string) => string;
// Message: There must be 1 space before "foo" parameter type annotation colon.
type X = (foo? :string) => string;
// Message: There must be no space before "foo" parameter type annotation colon.
type X = (foo? :string) => string;
// Message: There must be no space before "foo" parameter type annotation colon.
// Options: ["always"]
type X = (foo?:string) => string;
// Message: There must be a space before "foo" parameter type annotation colon.
type X = (foo? :?string) => string;
// Message: There must be no space before "foo" parameter type annotation colon.
class X { foo :string }
// Message: There must be no space before "foo" class property type annotation colon.
// Options: ["always"]
class X { foo: string }
// Message: There must be a space before "foo" class property type annotation colon.
class X { foo :?string }
// Message: There must be no space before "foo" class property type annotation colon.
// Options: ["always"]
class X { foo: ?string }
// Message: There must be a space before "foo" class property type annotation colon.
class X { static foo : number }
// Message: There must be no space before "foo" class property type annotation colon.
class X { static foo :number }
// Message: There must be no space before "foo" class property type annotation colon.
// Options: ["always"]
class X { static foo: number }
// Message: There must be a space before "foo" class property type annotation colon.
// Options: ["always"]
class X { static foo:number }
// Message: There must be a space before "foo" class property type annotation colon.
declare class Foo { static bar :number; }
// Message: There must be no space before "bar" type annotation colon.
declare class Foo { static bar : number; }
// Message: There must be no space before "bar" type annotation colon.
// Options: ["always"]
declare class Foo { static bar:number; }
// Message: There must be a space before "bar" type annotation colon.
// Options: ["always"]
declare class Foo { static bar: number; }
// Message: There must be a space before "bar" type annotation colon.
// Options: ["always"]
class X { +foo: string }
// Message: There must be a space before "foo" class property type annotation colon.
// Options: ["always"]
class X { +foo : string }
// Message: There must be 1 space before "foo" class property type annotation colon.
// Options: ["never"]
class X { +foo : string }
// Message: There must be no space before "foo" class property type annotation colon.
// Options: ["always"]
class X { static +foo: string }
// Message: There must be a space before "foo" class property type annotation colon.
// Options: ["always"]
class X { static +foo : string }
// Message: There must be 1 space before "foo" class property type annotation colon.
// Options: ["never"]
class X { static +foo : string }
// Message: There must be no space before "foo" class property type annotation colon.
type X = { foo : string }
// Message: There must be no space before "foo" type annotation colon.
// Options: ["never"]
type X = { foo : string }
// Message: There must be no space before "foo" type annotation colon.
// Options: ["always"]
type X = { foo: string }
// Message: There must be a space before "foo" type annotation colon.
// Options: ["always"]
type X = { foo : string }
// Message: There must be 1 space before "foo" type annotation colon.
type X = { foo? : string }
// Message: There must be no space before "foo" type annotation colon.
// Options: ["always"]
type X = { foo?: string }
// Message: There must be a space before "foo" type annotation colon.
// Options: ["always"]
type X = { foo? : string }
// Message: There must be 1 space before "foo" type annotation colon.
// Options: ["always"]
type X = { foo ?: string }
// Message: There must be a space before "foo" type annotation colon.
// Options: ["always"]
type X = { +foo: string }
// Message: There must be a space before "foo" type annotation colon.
// Options: ["always"]
type X = { +foo : string }
// Message: There must be 1 space before "foo" type annotation colon.
// Options: ["never"]
type X = { +foo : string }
// Message: There must be no space before "foo" type annotation colon.
// Options: ["always"]
type X = { +foo?: string }
// Message: There must be a space before "foo" type annotation colon.
// Options: ["always"]
type X = { +foo? : string }
// Message: There must be 1 space before "foo" type annotation colon.
// Options: ["never"]
type X = { +foo? : string }
// Message: There must be no space before "foo" type annotation colon.
// Options: ["always"]
type X = { [a: b] : c }
// Message: There must be a space before type annotation colon.
// Options: ["never"]
type X = { [a : b]: c }
// Message: There must be no space before type annotation colon.
// Options: ["always"]
type X = { [a : b] : c }
// Message: There must be 1 space before type annotation colon.
// Options: ["always"]
type X = { +[a:b] : c }
// Message: There must be a space before type annotation colon.
// Options: ["never"]
type X = { +[a : b]: c }
// Message: There must be no space before type annotation colon.
// Options: ["always"]
type X = { +[a : b] : c }
// Message: There must be 1 space before type annotation colon.
// Options: ["always"]
type X = { [a : b]: c }
// Message: There must be a space before type annotation colon.
// Options: ["never"]
type X = { [a: b] : c }
// Message: There must be no space before type annotation colon.
// Options: ["always"]
type X = { [a : b] : c }
// Message: There must be 1 space before type annotation colon.
// Options: ["always"]
type X = { [a:b]:c }
// Message: There must be a space before type annotation colon.
// Message: There must be a space before type annotation colon.
// Options: ["never"]
type X = { [a : b] : c }
// Message: There must be no space before type annotation colon.
// Message: There must be no space before type annotation colon.
// Options: ["always"]
type X = { [a : b] : c }
// Message: There must be 1 space before type annotation colon.
// Message: There must be 1 space before type annotation colon.
// Options: ["always"]
type X = { [a:(b)]:(c) }
// Message: There must be a space before type annotation colon.
// Message: There must be a space before type annotation colon.
// Options: ["never"]
type X = { [a : (b)] : (c) }
// Message: There must be no space before type annotation colon.
// Message: There must be no space before type annotation colon.
// Options: ["never"]
const x = ({} :{})
// Message: There must be no space before type cast colon.
// Options: ["always"]
const x = ({}:{})
// Message: There must be a space before type cast colon.
// Options: ["always"]
const x = ({} :{})
// Message: There must be 1 space before type cast colon.
// Options: ["never"]
((x) : string)
// Message: There must be no space before type cast colon.
// Options: ["always"]
((x): string)
// Message: There must be a space before type cast colon.
// Options: ["always"]
((x) : string)
// Message: There must be 1 space before type cast colon.
// Options: ["always"]
const x:number = 7;
// Message: There must be a space before const type annotation colon.
// Options: ["always"]
let x:number = 42;
// Message: There must be a space before let type annotation colon.
// Options: ["always"]
var x:number = 42;
// Message: There must be a space before var type annotation colon.
The following patterns are not considered problems:
(foo) => {}
(foo: string) => {}
(foo?: string) => {}
(foo ?: string) => {}
// Options: ["never"]
(foo: string) => {}
// Options: ["always"]
(foo : string) => {}
// Options: ["always"]
(foo? : string) => {}
// Options: ["always"]
(foo ? : string) => {}
// Options: ["always"]
(foo ? : string) => {}
({ lorem, ipsum, dolor }: SomeType) => {}
(foo: { a: string, b: number }) => {}
({ a, b }: ?{ a: string, b: number }) => {}
(): { a: number, b: string } => {}
// Options: ["always"]
() : { a : number, b : string } => {}
([ a, b ]: string[]) => {}
(): x => {}
// Options: ["always"]
() : x => {}
(): (number | string) => {}
// Options: ["always"]
() : (number | string) => {}
function x(foo: string) {}
// Options: ["always"]
function x(foo : string) {}
var x = function (foo: string) {}
// Options: ["always"]
var x = function (foo : string) {}
class X { foo({ bar }: Props = this.props) {} }
class Foo { constructor(foo: string ) {} }
// Options: ["always"]
class Foo { constructor(foo : string ) {} }
async function foo({ lorem, ipsum, dolor }: SomeType) {}
function x({ a, b }: { a: string, b: number }) {}
function a(): x {}
// Options: ["always"]
function a() : x {}
function a(): (number | string) {}
// Options: ["always"]
function a() : (number | string) {}
type X = (foo:string) => number;
type X = (foo: string) => number;
type X = (foo: ?string) => number;
type X = (foo?: string) => number;
type X = (foo?: ?string) => number;
type X = (foo ?: string) => number;
// Options: ["always"]
type X = (foo? : string) => number
// Options: ["always"]
type X = (foo? : ?string) => number
type X = (number) => string;
type X = (?number) => string;
type X = number => string;
type X = ?number => string;
type X = ({ foo: bar }) => string;
// Options: ["always"]
type X = (number) => string;
// Options: ["always"]
type X = (?number) => string;
// Options: ["always"]
type X = number => string;
// Options: ["always"]
type X = ?number => string;
// Options: ["always"]
type X = ({ foo : bar }) => string;
class Foo { bar }
class Foo { bar = 3 }
class Foo { bar: string }
class Foo { bar: ?string }
class Foo { bar:?string }
// Options: ["always"]
class Foo { bar : string }
class X { static foo:number }
class X { static foo: number }
// Options: ["always"]
class X { static foo :number }
// Options: ["always"]
class X { static foo : number }
declare class Foo { static bar:number; }
// Options: ["always"]
declare class Foo { static bar :number; }
declare class Foo { static bar: number; }
// Options: ["always"]
declare class Foo { static bar : number; }
class X { +foo: string }
class X { static +foo: string }
// Options: ["always"]
class X { +foo : string }
// Options: ["always"]
class X { static +foo : string }
type X = { foo: string }
// Options: ["always"]
type X = { foo : string }
type X = { foo?: string }
type X = { foo ?: string }
// Options: ["always"]
type X = { foo? : string }
type X = { +foo: string }
type X = { +foo?: string }
// Options: ["always"]
type X = { +foo : string }
// Options: ["always"]
type X = { +foo? : string }
// Options: ["always"]
type X = { [a : b] : c }
// Options: ["never"]
type X = { [a:b]:c }
// Options: ["always"]
type X = { [string] : c }
// Options: ["never"]
type X = { [string]:c }
// Options: ["always"]
type X = { +[a : b] : c }
// Options: ["never"]
type X = { +[a:b]:c }
// Options: ["always"]
type X = { [a : (b)] : (c) }
// Options: ["never"]
type X = { [a:(b)]:(c) }
// Options: ["never"]
const x = ({}:{})
// Options: ["always"]
const x = ({} :{})
// Options: ["never"]
((x): string)
// Options: ["always"]
((x) : string)
// Options: ["always"]
const x :number = 7;
// Options: ["always"]
let x :number = 42;
// Options: ["always"]
var x :number = 42;
type-id-matchEnforces a consistent naming pattern for type aliases.
This rule needs a text RegExp to operate with Its signature is as follows:
{
"rules": {
"flowtype/type-id-match": [
2,
"^([A-Z][a-z0-9]*)+Type$"
]
}
}
'^([A-Z][a-z0-9]*)+Type$' is the default pattern.
The following patterns are considered problems:
type foo = {};
// Message: Type identifier 'foo' does not match pattern '/^([A-Z][a-z0-9]*)+Type$/'.
// Options: ["^foo$"]
type FooType = {};
// Message: Type identifier 'FooType' does not match pattern '/^foo$/'.
The following patterns are not considered problems:
type FooType = {};
// Options: ["^foo$"]
type foo = {};
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
type foo = {};
type-import-styleThe --fix option on the command line automatically fixes problems reported by this rule.
Enforces a particular style for type imports:
// 'identifier' style
import {type T, type U, type V} from '...';
// 'declaration' style
import type {T, U, V} from '...';
The rule has a string option:
"identifier" (default): Enforces that type imports are all in the
'identifier' style."declaration": Enforces that type imports are all in the 'declaration'
style.The following patterns are considered problems:
import type {A, B} from 'a';
// Message: Unexpected "import type"
// Options: ["identifier"]
import type {A, B} from 'a';
// Message: Unexpected "import type"
// Options: ["identifier"]
import type {A, B as C} from 'a';
// Message: Unexpected "import type"
// Options: ["identifier"]
import type A from 'a';
// Message: Unexpected "import type"
// Options: ["declaration"]
import {type A, type B} from 'a';
// Message: Unexpected type import
// Message: Unexpected type import
The following patterns are not considered problems:
import {type A, type B} from 'a';
// Options: ["identifier"]
import {type A, type B} from 'a';
// Options: ["declaration"]
import type {A, B} from 'a';
union-intersection-spacingThe --fix option on the command line automatically fixes problems reported by this rule.
Enforces consistent spacing around union and intersection type separators (| and &).
This rule takes one argument. If it is 'always' then a problem is raised when there is no space around the separator. If it is 'never' then a problem is raised when there is a space around the separator.
The default value is 'always'.
The following patterns are considered problems:
type X = string| number;
// Message: There must be a space before union type annotation separator
// Options: ["always"]
type X = string| number;
// Message: There must be a space before union type annotation separator
type X = string |number;
// Message: There must be a space after union type annotation separator
type X = string|number;
// Message: There must be a space before union type annotation separator
// Message: There must be a space after union type annotation separator
type X = {x: string}|{y: number};
// Message: There must be a space before union type annotation separator
// Message: There must be a space after union type annotation separator
type X = string | number |boolean;
// Message: There must be a space after union type annotation separator
type X = string|number|boolean;
// Message: There must be a space before union type annotation separator
// Message: There must be a space after union type annotation separator
// Message: There must be a space before union type annotation separator
// Message: There must be a space after union type annotation separator
type X = (string)| number;
// Message: There must be a space before union type annotation separator
type X = ((string))|(number | foo);
// Message: There must be a space before union type annotation separator
// Message: There must be a space after union type annotation separator
// Options: ["never"]
type X = string |number;
// Message: There must be no space before union type annotation separator
// Options: ["never"]
type X = string| number;
// Message: There must be no space after union type annotation separator
type X = string& number;
// Message: There must be a space before intersection type annotation separator
// Options: ["always"]
type X = string& number;
// Message: There must be a space before intersection type annotation separator
type X = string &number;
// Message: There must be a space after intersection type annotation separator
type X = {x: string}&{y: number};
// Message: There must be a space before intersection type annotation separator
// Message: There must be a space after intersection type annotation separator
type X = string&number;
// Message: There must be a space before intersection type annotation separator
// Message: There must be a space after intersection type annotation separator
type X = string & number &boolean;
// Message: There must be a space after intersection type annotation separator
type X = string&number&boolean;
// Message: There must be a space before intersection type annotation separator
// Message: There must be a space after intersection type annotation separator
// Message: There must be a space before intersection type annotation separator
// Message: There must be a space after intersection type annotation separator
type X = (string)& number;
// Message: There must be a space before intersection type annotation separator
type X = ((string))&(number & foo);
// Message: There must be a space before intersection type annotation separator
// Message: There must be a space after intersection type annotation separator
// Options: ["never"]
type X = string &number;
// Message: There must be no space before intersection type annotation separator
// Options: ["never"]
type X = string& number;
// Message: There must be no space after intersection type annotation separator
The following patterns are not considered problems:
type X = string | number;
type X = string | number | boolean;
type X = (string) | number;
type X = ((string)) | (number | foo);
// Options: ["never"]
type X = string|number
type X =
| string
| number
function x() {
type X =
| string
| number
}
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
type X = string| number;
type X = string & number;
type X = string & number & boolean;
type X = (string) & number;
type X = ((string)) & (number & foo);
// Options: ["never"]
type X = string&number
type X =
& string
& number
function x() {
type X =
& string
& number
}
// Settings: {"flowtype":{"onlyFilesWithFlowAnnotation":true}}
type X = string& number;
use-flow-typeMarks Flow type alias declarations as used.
Used to suppress no-unused-vars errors that are triggered by type aliases.
The following patterns are not considered problems:
declare class A {}
// Additional rules: {"no-unused-vars":1}
declare function A(): Y
// Additional rules: {"no-unused-vars":1}
declare module A {}
// Additional rules: {"no-unused-vars":1}
declare module A { declare var a: Y }
// Additional rules: {"no-unused-vars":1}
declare var A: Y
// Additional rules: {"no-unused-vars":1}
import type A from "a"; (function<T: A>(): T {})
// Additional rules: {"no-unused-vars":1}
(function<T: A>(): T {}); import type A from "a"
// Additional rules: {"no-unused-vars":1}
import type {A} from "a"; (function<T: A>(): T {})
// Additional rules: {"no-unused-vars":1}
(function<T: A>(): T {}); import type {A} from "a"
// Additional rules: {"no-unused-vars":1}
(function<T: A>(): T {}); import type {a as A} from "a"
// Additional rules: {"no-unused-vars":1}
type A = {}; function x<Y: A>(i: Y) { i }; x()
// Additional rules: {"no-unused-vars":1}
function x<Y: A>(i: Y) { i }; type A = {}; x()
// Additional rules: {"no-unused-vars":1}
type A = {}; function x<Y: A.B.C>(i: Y) { i }; x()
// Additional rules: {"no-unused-vars":1}
function x<Y: A.B.C>(i: Y) { i }; type A = {}; x()
// Additional rules: {"no-unused-vars":1}
valid-syntaxDeprecated Babylon (the Babel parser) v6.10.0 fixes parsing of the invalid syntax this plugin warned against.
Checks for simple Flow syntax errors.
FAQs
Flowtype linting rules for ESLint.
The npm package eslint-plugin-flowtype receives a total of 3,792,930 weekly downloads. As such, eslint-plugin-flowtype popularity was classified as popular.
We found that eslint-plugin-flowtype demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Socket's package search now displays weekly downloads for npm packages, helping developers quickly assess popularity and make more informed decisions.
Security News
A Stanford study reveals 9.5% of engineers contribute almost nothing, costing tech $90B annually, with remote work fueling the rise of "ghost engineers."
Research
Security News
Socket’s threat research team has detected six malicious npm packages typosquatting popular libraries to insert SSH backdoors.